package org.jeecg.modules.simulator.model.person.path;

import lombok.Getter;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @program: gp2
 * @description:
 * @author: lydms
 * @create: 2024-08-20 15:13
 **/
public class PersonPath  extends LinkedList<PersonPathItem> {
    String personPathId;
    //路径节点
    @Getter
    Map<String,PersonPathItem> personPathItemMap;
    //乘车方向map
    Map<String,String> personDirectionMap;
    //换乘方向节点
    Map<Integer,PersonPathItem> transferNodeMap=new HashMap<>();
    //反向的换乘节点，就是通过站名查找换乘节点索引
    Map<String,Integer> InverseTransferNodeMap=new HashMap<>();
    Map<String,String> offStationNameMap=new HashMap<>();

    //下车方向节点--Map<本站名字,本站名字-下一站名字>
    Map<String,String> personOffNodeMap=new HashMap<>();

    Map<String,String> lineIdMap=new HashMap<>();





    boolean isNeedTransfer=false;

    public PersonPath(List<PersonPathItem> personPathItemList) {
        super(personPathItemList);
        this.personPathItemMap=new HashMap<>();
        this.personDirectionMap=new HashMap<>();
        // 使用默认的比较器对整数列表进行排序（升序）
        Collections.sort(this);
        int size=this.size();
        transferNodeMap.put(1,this.getFirst());

//        List<String> lineId=new ArrayList<>();
        for(int i=0;i<size;i++) {
            transferNodeAdd(i);
            //正常节点加入
            personPathItemMap.put(this.get(i).stationName,this.get(i));
            DirMapAdd(size, i, this, this.personDirectionMap);
        }



        offStationNameMap.put(this.getLast().index+"",this.getLast().stationName);

        Integer maxKey = getMaxKey(transferNodeMap);
        transferNodeMap.put(maxKey+1,this.getLast());
        offNodeDirAdd(size);


        transferNodeMap.forEach((k,v)->{
            InverseTransferNodeMap.put(v.stationName,k);
        });

    }
    //下车方向节点
    private void offNodeDirAdd(int size) {
        int offNodeSize=transferNodeMap.values().size();
        if(offNodeSize==2){
            personOffNodeMap.put(this.getFirst().stationName,this.getFirst().stationName+"-"+this.getLast().stationName);
        }else{
            List<PersonPathItem> pplist =transferNodeMap.values().stream().collect(Collectors.toList());
            for(int k=0;k<offNodeSize;k++){
                DirMapAdd(offNodeSize, k, pplist, this.personOffNodeMap);
            }
        }
    }


    public  Integer getMaxKey(Map<Integer, PersonPathItem> map) {
        Integer maxKey = null;

        for (Integer key : map.keySet()) {
            if (maxKey == null || key > maxKey) {
                maxKey = key;
            }
        }

        return maxKey;
    }
    //换乘节点Map添加数据和下车站map添加数据
    private void transferNodeAdd(int i) {

        if(this.get(i).isNeedTransfer){

            offStationNameMap.put(this.get(i).index+"",this.get(i).stationName);
            int key=getMaxKey(transferNodeMap);
            transferNodeMap.put( key+1,this.get(i));
        }
    }
    /**
     * @description: Map<本站名字,本站名字-下一站名字>
     *
     * @author:  renzhg
     * @date:  2024/9/23 13:54
     **/
    private void DirMapAdd(int size, int i, List<PersonPathItem> personPathItems, Map<String, String> strMap) {
        if (i != size - 1) {
            //方向正常加入
            String value = personPathItems.get(i).stationName + "-" + personPathItems.get(i + 1).stationName;
            strMap.put(personPathItems.get(i).stationName, value);
        } else {
            String value = "end";
            strMap.put(personPathItems.get(i).stationName, value);
        }
    }

    /**
     * 给出下车节点的方向
     * @param stationName
     * @return
     */
    public String getNextOffNodeStaionStr(String stationName){
        return this.personOffNodeMap.get(stationName);
    }
    /**
     * 给出对应的方向
     * @param stationName
     * @return
     */
    public String getNextDirection(String stationName){
        return this.personDirectionMap.get(stationName);
    }

    /**
     * 获取起始站点
     * @return
     */
    public String getOStationName(){
        return this.getFirst().stationName;
    }

    /**
     * 获取终止站点
     * @return
     */
    public String getDStationName(){
        return this.getLast().stationName;
    }



/**
 * @description: 给定任意一站，获取下车站的方向字符串
 *
 * @author:  renzhg
 * @date:  2024/10/8 16:52
 **/
    public String getNodeStr(String stationName){
        if(isNeedTransfer){
            Collections.sort(this);
            for(int i=personPathItemMap.get(stationName).index;i<this.size();i++){
                if(this.get(i).isNeedTransfer){
                    String stationEndName=this.get(i).getStationName();
                   int index= InverseTransferNodeMap.get(stationEndName);
                    String stationStartName=transferNodeMap.get(index-1).getStationName();
                    return stationStartName+"-"+stationEndName;

                }
            }



        }else{
            return this.getNextOffNodeStaionStr(getOStationName());

        }
        return "";


    }


    public boolean isOffStation(String stationname){
        return offStationNameMap.containsValue(stationname);
    }






}
